import ajax from 'uni-ajax'
import qs from "qs";
import Config from '@/utils/config.js'
import refreshToken from '@/utils/refresh.js'
import {
	setUserLoginTime
} from '@/utils/auth.js';

const instance = ajax.create({
	baseURL: Config.baseURL
})

// 声明一个 Map 用于存储每个请求的标识 和 取消函数
const pending = new Map();

// 添加请求
const addPending = (config) => {
	const url = [
		config.method,
		config.url,
		qs.stringify(config.params),
		qs.stringify(config.data),
	].join("&");
	// if (!config.cancelToken) {
	//   // instance().abort()
	//   if (!pending.has(url)) {
	//     // 如果 pending 中不存在当前请求，则添加进去
	//     pending.set(url);
	//   }
	// }
	// config.cancelToken =
	//   config.cancelToken
	// config.cancelToken ||
	// new axios.CancelToken((cancel) => {
	//   if (!pending.has(url)) {
	//     // 如果 pending 中不存在当前请求，则添加进去
	//     pending.set(url, cancel);
	//   }
	// });
	// instance.abort()
}

// 移除请求
const removePending = (config) => {
	const url = [
		config.method,
		config.url,
		qs.stringify(config.params),
		qs.stringify(config.data),
	].join("&");
	if (pending.has(url)) {
		// 如果在 pending 中存在当前请求标识，需要取消当前请求，并且移除
		const cancel = pending.get(url);
		cancel(url);
		pending.delete(url);
	}
}

// 添加请求拦截器
instance.interceptors.request.use(
	async (config) => {
			let timestamp = Math.round(new Date().getTime());
			let loginTime = uni.getStorageSync('loginTime');
			let token = uni.getStorageSync('token');

			if (loginTime && token) {
				if (timestamp - loginTime > 7200000) {
					setUserLoginTime(timestamp)

					return refreshToken().then(() => instance(response.config))
				}
			}

			removePending(config) // 在请求开始前，对之前的请求做检查取消操作
			addPending(config) // 将当前请求添加到 pending 中

			// 在发送请求前
			config.header = Config.commonHeader()

			return config
		},
		error => {
			// 错误抛到业务代码
			error.data = {};
			error.data.msg = "服务器异常，请联系管理员！";
			uni.showToast({
				title: error.data.msg,
				icon: 'none',
				duration: 2000
			})

			// 对请求错误做些什么
			return Promise.reject(error)
		}
)

// 添加响应拦截器
instance.interceptors.response.use(
	response => {
		removePending(response)

		const status = response.status;
		let msg = "";

		if (status < 200 || status >= 300) {
			// 处理http错误，抛到业务代码
			msg = showStatus(status);
			if (typeof response.data === "string") {
				response.data = {
					msg
				};
			} else {
				response.data.msg = msg;
			}
		} else {
			if (response.data.code !== 20000) {
				if (response.data.code === 40003 || response.data.code === 40001) {
					uni.clearStorageSync()
					uni.redirectTo({
						url: '/pages/views/login/login'
					})
				} else {
					if (response.data.message) {
						uni.showToast({
							title: response.data.message,
							icon: 'none',
							duration: 2000
						})

					}
				}
			}
		}

		// 对响应数据做些什么
		return response.data
	},
	error => {
		// 错误抛到业务代码
		error.data = {};
		error.data.msg = "请求超时或服务器异常，请检查网络或联系管理员！";
		uni.showToast({
			title: error.data.msg,
			icon: 'none',
			duration: 2000
		})


		// 对响应错误做些什么
		return Promise.reject(error)
	}
)

export default instance

// 刷新 token 方法
async function doRequest(response) {

	const {
		data
	} = await instance({
		url: 'system/login/refreshToken',
		method: 'post'
	})



	if (data.code == 2000) {
		uni.setStorageSync('token', data.result)
		let config = response
		const resold = await execute(config.name, {
			...config.data
		})
		return resold
	} else {
		uni.clearStorageSync()
		uni.showToast({
			title: '登陆过期请重新登录！',
			icon: "none",
			success() {
				uni.navigateTo({
					url: '/pages/views/login/login'
				})
			}
		});
	}
}